package o;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import o.el.c;
import o.eo.a;

public class eg {
    public static void ˎ(ek ekVar) {
        if ((ekVar.ˋ() & 32) != 32) {
            ॱ(ekVar);
            return;
        }
        boolean z;
        ekVar.ˋʼ = true;
        ekVar.ʿॱ = false;
        ekVar.ˊʻ = false;
        ekVar.ˈॱ = false;
        List<el> list = ekVar.ˌॱ;
        List<es> list2 = ekVar.ʽᐝ;
        boolean z2 = ekVar.ˍ() == c.WRAP_CONTENT;
        if (ekVar.ˌ() == c.WRAP_CONTENT) {
            z = true;
        } else {
            z = false;
        }
        boolean z3;
        if (z2 || z) {
            z3 = true;
        } else {
            z3 = false;
        }
        list2.clear();
        for (el elVar : list) {
            elVar.ॱˎ = null;
            elVar.ꜟ = false;
            elVar.ˊ();
        }
        for (el elVar2 : list) {
            if (elVar2.ॱˎ == null && !ॱ(elVar2, (List) list2, r4)) {
                ॱ(ekVar);
                ekVar.ˋʼ = false;
                return;
            }
        }
        int i = 0;
        int i2 = 0;
        for (es esVar : list2) {
            i2 = Math.max(i2, ˋ(esVar, 0));
            i = Math.max(i, ˋ(esVar, 1));
        }
        if (z2) {
            ekVar.ˋ(c.FIXED);
            ekVar.ᐝ(i2);
            ekVar.ʿॱ = true;
            ekVar.ˊʻ = true;
            ekVar.ˊʼ = i2;
        }
        if (z) {
            ekVar.ˊ(c.FIXED);
            ekVar.ॱˊ(i);
            ekVar.ʿॱ = true;
            ekVar.ˈॱ = true;
            ekVar.ˉॱ = i;
        }
        ˋ(list2, 0, ekVar.ॱᐝ());
        ˋ(list2, 1, ekVar.ᐝॱ());
    }

    private static boolean ॱ(el elVar, List<es> list, boolean z) {
        es esVar = new es(new ArrayList(), true);
        list.add(esVar);
        return ˋ(elVar, esVar, list, z);
    }

    private static boolean ˋ(el elVar, es esVar, List<es> list, boolean z) {
        if (elVar == null) {
            return true;
        }
        elVar.ᐝᐝ = false;
        ek ekVar = (ek) elVar.ॱˊ();
        if (elVar.ॱˎ == null) {
            int i;
            elVar.ᐝˊ = true;
            esVar.ॱ.add(elVar);
            elVar.ॱˎ = esVar;
            if (elVar.ᐝॱ.ˋ == null && elVar.ʼॱ.ˋ == null && elVar.ʻॱ.ˋ == null && elVar.ʽॱ.ˋ == null && elVar.ʿ.ˋ == null && elVar.ˊˊ.ˋ == null) {
                ॱ(ekVar, elVar, esVar);
                if (z) {
                    return false;
                }
            }
            if (!(elVar.ʻॱ.ˋ == null || elVar.ʽॱ.ˋ == null)) {
                if (ekVar.ˌ() == c.WRAP_CONTENT) {
                    if (z) {
                        ॱ(ekVar, elVar, esVar);
                        return false;
                    } else if (!(elVar.ʻॱ.ˋ.ˎ == elVar.ॱˊ() && elVar.ʽॱ.ˋ.ˎ == elVar.ॱˊ())) {
                        ॱ(ekVar, elVar, esVar);
                    }
                } else if (z) {
                    ॱ(ekVar, elVar, esVar);
                    return false;
                } else {
                    ॱ(ekVar, elVar, esVar);
                }
            }
            if (!(elVar.ᐝॱ.ˋ == null || elVar.ʼॱ.ˋ == null)) {
                if (ekVar.ˍ() == c.WRAP_CONTENT) {
                    if (z) {
                        ॱ(ekVar, elVar, esVar);
                        return false;
                    } else if (!(elVar.ᐝॱ.ˋ.ˎ == elVar.ॱˊ() && elVar.ʼॱ.ˋ.ˎ == elVar.ॱˊ())) {
                        ॱ(ekVar, elVar, esVar);
                    }
                } else if (z) {
                    ॱ(ekVar, elVar, esVar);
                    return false;
                } else {
                    ॱ(ekVar, elVar, esVar);
                }
            }
            int i2 = elVar.ˍ() == c.MATCH_CONSTRAINT ? 1 : 0;
            if (elVar.ˌ() == c.MATCH_CONSTRAINT) {
                i = 1;
            } else {
                i = 0;
            }
            if ((i2 ^ i) != 0 && elVar.ˋᐝ != 0.0f) {
                ˋ(elVar);
            } else if (elVar.ˍ() == c.MATCH_CONSTRAINT || elVar.ˌ() == c.MATCH_CONSTRAINT) {
                ॱ(ekVar, elVar, esVar);
                if (z) {
                    return false;
                }
            }
            if (((elVar.ᐝॱ.ˋ == null && elVar.ʼॱ.ˋ == null) || ((elVar.ᐝॱ.ˋ != null && elVar.ᐝॱ.ˋ.ˎ == elVar.ˊˋ && elVar.ʼॱ.ˋ == null) || ((elVar.ʼॱ.ˋ != null && elVar.ʼॱ.ˋ.ˎ == elVar.ˊˋ && elVar.ᐝॱ.ˋ == null) || (elVar.ᐝॱ.ˋ != null && elVar.ᐝॱ.ˋ.ˎ == elVar.ˊˋ && elVar.ʼॱ.ˋ != null && elVar.ʼॱ.ˋ.ˎ == elVar.ˊˋ)))) && elVar.ˊˊ.ˋ == null && !(elVar instanceof ep) && !(elVar instanceof et)) {
                esVar.ʻ.add(elVar);
            }
            if (((elVar.ʻॱ.ˋ == null && elVar.ʽॱ.ˋ == null) || ((elVar.ʻॱ.ˋ != null && elVar.ʻॱ.ˋ.ˎ == elVar.ˊˋ && elVar.ʽॱ.ˋ == null) || ((elVar.ʽॱ.ˋ != null && elVar.ʽॱ.ˋ.ˎ == elVar.ˊˋ && elVar.ʻॱ.ˋ == null) || (elVar.ʻॱ.ˋ != null && elVar.ʻॱ.ˋ.ˎ == elVar.ˊˋ && elVar.ʽॱ.ˋ != null && elVar.ʽॱ.ˋ.ˎ == elVar.ˊˋ)))) && elVar.ˊˊ.ˋ == null && elVar.ʿ.ˋ == null && !(elVar instanceof ep) && !(elVar instanceof et)) {
                esVar.ʽ.add(elVar);
            }
            if (elVar instanceof et) {
                ॱ(ekVar, elVar, esVar);
                if (z) {
                    return false;
                }
                et etVar = (et) elVar;
                for (i = 0; i < etVar.ʼˊ; i++) {
                    if (!ˋ(etVar.ʻᐝ[i], esVar, list, z)) {
                        return false;
                    }
                }
            }
            for (eo eoVar : elVar.ˋˊ) {
                if (!(eoVar.ˋ == null || eoVar.ˋ.ˎ == elVar.ॱˊ())) {
                    if (eoVar.ˏ == a.CENTER) {
                        ॱ(ekVar, elVar, esVar);
                        if (z) {
                            return false;
                        }
                    }
                    ˏ(eoVar);
                    if (!ˋ(eoVar.ˋ.ˎ, esVar, list, z)) {
                        return false;
                    }
                }
            }
            return true;
        }
        if (elVar.ॱˎ != esVar) {
            esVar.ॱ.addAll(elVar.ॱˎ.ॱ);
            esVar.ʻ.addAll(elVar.ॱˎ.ʻ);
            esVar.ʽ.addAll(elVar.ॱˎ.ʽ);
            if (!elVar.ॱˎ.ˎ) {
                esVar.ˎ = false;
            }
            list.remove(elVar.ॱˎ);
            for (el elVar2 : elVar.ॱˎ.ॱ) {
                elVar2.ॱˎ = esVar;
            }
        }
        return true;
    }

    private static void ॱ(ek ekVar, el elVar, es esVar) {
        esVar.ˎ = false;
        ekVar.ˋʼ = false;
        elVar.ᐝˊ = false;
    }

    private static int ˋ(es esVar, int i) {
        int i2 = i * 2;
        List ˊ = esVar.ˊ(i);
        int size = ˊ.size();
        int i3 = 0;
        int i4 = 0;
        while (i3 < size) {
            boolean z;
            el elVar = (el) ˊ.get(i3);
            if (elVar.ˋˊ[i2 + 1].ˋ == null || !(elVar.ˋˊ[i2].ˋ == null || elVar.ˋˊ[i2 + 1].ˋ == null)) {
                z = true;
            } else {
                z = false;
            }
            i3++;
            i4 = Math.max(i4, ˏ(elVar, i, z, 0));
        }
        esVar.ˋ[i] = i4;
        return i4;
    }

    private static int ˏ(el elVar, int i, boolean z, int i2) {
        if (!elVar.ᐝˊ) {
            return 0;
        }
        int i3;
        int i4;
        int ˊᐝ;
        int i5;
        int i6;
        int i7;
        int i8;
        int i9;
        Object obj = (elVar.ʿ.ˋ == null || i != 1) ? null : 1;
        if (z) {
            i3 = i * 2;
            int ᐝॱ = elVar.ᐝॱ() - elVar.ˊᐝ();
            i4 = i3 + 1;
            ˊᐝ = elVar.ˊᐝ();
            i5 = ᐝॱ;
        } else {
            ˊᐝ = i * 2;
            i3 = ˊᐝ + 1;
            i4 = ˊᐝ;
            ˊᐝ = elVar.ᐝॱ() - elVar.ˊᐝ();
            i5 = elVar.ˊᐝ();
        }
        if (elVar.ˋˊ[i4].ˋ == null || elVar.ˋˊ[i3].ˋ != null) {
            i6 = 1;
            i7 = i4;
            i8 = i3;
        } else {
            i6 = -1;
            i7 = i3;
            i8 = i4;
        }
        if (obj != null) {
            i2 -= ˊᐝ;
        }
        int ˏ = (elVar.ˋˊ[i8].ˏ() * i6) + ˊ(elVar, i);
        int i10 = ˏ + i2;
        int ॱᐝ = (i == 0 ? elVar.ॱᐝ() : elVar.ᐝॱ()) * i6;
        Iterator it = elVar.ˋˊ[i8].ˎ().ॱॱ.iterator();
        i3 = 0;
        while (it.hasNext()) {
            i3 = Math.max(i3, ˏ(((ev) ((eu) it.next())).ˏ.ˎ, i, z, i10));
        }
        it = elVar.ˋˊ[i7].ˎ().ॱॱ.iterator();
        int i11 = 0;
        while (it.hasNext()) {
            i11 = Math.max(i11, ˏ(((ev) ((eu) it.next())).ˏ.ˎ, i, z, ॱᐝ + i10));
        }
        if (obj != null) {
            i11 += i5;
            i9 = i3 - ˊᐝ;
        } else {
            i11 = ((i == 0 ? elVar.ॱᐝ() : elVar.ᐝॱ()) * i6) + i11;
            i9 = i3;
        }
        if (i == 1) {
            it = elVar.ʿ.ˎ().ॱॱ.iterator();
            i3 = 0;
            while (it.hasNext()) {
                ev evVar = (ev) ((eu) it.next());
                if (i6 == 1) {
                    i4 = Math.max(i3, ˏ(evVar.ˏ.ˎ, i, z, ˊᐝ + i10));
                } else {
                    i4 = Math.max(i3, ˏ(evVar.ˏ.ˎ, i, z, (i5 * i6) + i10));
                }
                i3 = i4;
            }
            if (elVar.ʿ.ˎ().ॱॱ.size() > 0 && obj == null) {
                if (i6 == 1) {
                    i3 += ˊᐝ;
                } else {
                    i3 -= i5;
                }
            }
        } else {
            i3 = 0;
        }
        i4 = Math.max(i9, Math.max(i11, i3)) + ˏ;
        i5 = i2 + ˏ;
        ˊᐝ = i5 + ॱᐝ;
        if (i6 != -1) {
            ᐝॱ = ˊᐝ;
            ˊᐝ = i5;
            i5 = ᐝॱ;
        }
        if (z) {
            eq.ˎ(elVar, i, ˊᐝ);
            elVar.ˊ(ˊᐝ, i5, i);
        } else {
            elVar.ॱˎ.ˎ(elVar, i);
            elVar.ˏ(ˊᐝ, i);
        }
        if (elVar.ʻॱ(i) == c.MATCH_CONSTRAINT && elVar.ˋᐝ != 0.0f) {
            elVar.ॱˎ.ˎ(elVar, i);
        }
        if (elVar.ˋˊ[i8].ˋ == null || elVar.ˋˊ[i7].ˋ == null) {
            return i4;
        }
        el ॱˊ = elVar.ॱˊ();
        if (elVar.ˋˊ[i8].ˋ.ˎ != ॱˊ || elVar.ˋˊ[i7].ˋ.ˎ != ॱˊ) {
            return i4;
        }
        elVar.ॱˎ.ˎ(elVar, i);
        return i4;
    }

    private static void ˏ(eo eoVar) {
        eu ˎ = eoVar.ˎ();
        if (eoVar.ˋ != null && eoVar.ˋ.ˋ != eoVar) {
            eoVar.ˋ.ˎ().ॱ(ˎ);
        }
    }

    private static void ॱ(ek ekVar) {
        ekVar.ʽᐝ.clear();
        ekVar.ʽᐝ.add(0, new es(ekVar.ˌॱ));
    }

    public static void ˋ(List<es> list, int i, int i2) {
        int size = list.size();
        for (int i3 = 0; i3 < size; i3++) {
            for (el elVar : ((es) list.get(i3)).ˋ(i)) {
                if (elVar.ᐝˊ) {
                    ˎ(elVar, i, i2);
                }
            }
        }
    }

    private static void ˎ(el elVar, int i, int i2) {
        int i3 = i * 2;
        eo eoVar = elVar.ˋˊ[i3];
        eo eoVar2 = elVar.ˋˊ[i3 + 1];
        int i4 = (eoVar.ˋ == null || eoVar2.ˋ == null) ? 0 : 1;
        if (i4 != 0) {
            eq.ˎ(elVar, i, ˊ(elVar, i) + eoVar.ˏ());
        } else if (elVar.ˋᐝ == 0.0f || elVar.ʻॱ(i) != c.MATCH_CONSTRAINT) {
            i4 = i2 - elVar.ॱˋ(i);
            int ʻ = i4 - elVar.ʻ(i);
            elVar.ˊ(ʻ, i4, i);
            eq.ˎ(elVar, i, ʻ);
        } else {
            i4 = ˋ(elVar);
            i3 = (int) elVar.ˋˊ[i3].ˎ().ʼ;
            int i5 = i3 + i4;
            eoVar2.ˎ().ˊ = eoVar.ˎ();
            eoVar2.ˎ().ʼ = (float) i4;
            eoVar2.ˎ().ᐝ = 1;
            elVar.ˊ(i3, i5, i);
        }
    }

    private static int ˊ(el elVar, int i) {
        int i2 = i * 2;
        eo eoVar = elVar.ˋˊ[i2];
        eo eoVar2 = elVar.ˋˊ[i2 + 1];
        if (eoVar.ˋ == null || eoVar.ˋ.ˎ != elVar.ˊˋ || eoVar2.ˋ == null || eoVar2.ˋ.ˎ != elVar.ˊˋ) {
            return 0;
        }
        return (int) ((i == 0 ? elVar.ॱʼ : elVar.ᐝˋ) * ((float) (((elVar.ˊˋ.ʻ(i) - eoVar.ˏ()) - eoVar2.ˏ()) - elVar.ʻ(i))));
    }

    private static int ˋ(el elVar) {
        int i = -1;
        if (elVar.ˍ() == c.MATCH_CONSTRAINT) {
            if (elVar.ˋˋ == 0) {
                i = (int) (((float) elVar.ᐝॱ()) * elVar.ˋᐝ);
            } else {
                i = (int) (((float) elVar.ᐝॱ()) / elVar.ˋᐝ);
            }
            elVar.ᐝ(i);
        } else if (elVar.ˌ() == c.MATCH_CONSTRAINT) {
            if (elVar.ˋˋ == 1) {
                i = (int) (((float) elVar.ॱᐝ()) * elVar.ˋᐝ);
            } else {
                i = (int) (((float) elVar.ॱᐝ()) / elVar.ˋᐝ);
            }
            elVar.ॱˊ(i);
        }
        return i;
    }
}
